package com.team.service.mq;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.team.service.domain.vo.ServiceItemVo;
import com.team.service.service.IServiceItemService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * 缓存同步消息消费者
 * 专门处理Redis缓存的更新和删除
 */
@Component
@Slf4j
public class CacheSyncConsumer {

    @Autowired
    private StringRedisTemplate redisTemplate;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @Autowired
    private IServiceItemService serviceItemService;

    /**
     * 监听缓存同步队列
     *
     * @param message 消息内容
     */
    @RabbitListener(queues = "#{cacheSyncQueue.name}")
    public void handleCacheSyncMessage(String message) {
        log.info("接收到缓存同步消息：{}", message);
        
        try {
            // 解析消息
            Map<String, Object> messageMap = objectMapper.readValue(message, Map.class);
            String cacheKey = (String) messageMap.get("cacheKey");
            Integer expireSeconds = (Integer) messageMap.get("expireSeconds");
            
            // 检查是否是删除操作
            if (messageMap.containsKey("operation") && "delete".equals(messageMap.get("operation"))) {
                // 删除缓存
                redisTemplate.delete(cacheKey);
                log.info("缓存同步 - 已删除缓存：{}", cacheKey);
            } else {
                // 检查是否需要查询最新数据
                if (messageMap.containsKey("requireQuery") && (Boolean)messageMap.get("requireQuery")) {
                    // 获取实体ID
                    Object entityId = messageMap.get("entityId");
                    if (entityId != null) {
                        // 根据ID查询最新数据
                        Long id = null;
                        if (entityId instanceof Integer) {
                            id = ((Integer) entityId).longValue();
                        } else if (entityId instanceof Long) {
                            id = (Long) entityId;
                        } else if (entityId instanceof String) {
                            id = Long.parseLong((String) entityId);
                        } else if (entityId instanceof Double) {
                            id = ((Double) entityId).longValue();
                        }
                        
                        if (id != null) {
                            try {
                                // 使用Service层方法查询完整的VO对象（包含merchantName和categoryName）
                                ServiceItemVo serviceItemVo = serviceItemService.selectServiceItemById(id);
                                System.out.println(serviceItemVo);
                                if (serviceItemVo != null) {
                                    // 将完整VO对象序列化并存入Redis
                                    String jsonValue = objectMapper.writeValueAsString(serviceItemVo);
                                    redisTemplate.opsForValue().set(cacheKey, jsonValue, expireSeconds, TimeUnit.SECONDS);
                                    log.info("缓存同步 - 已查询并更新缓存(完整VO)：{}，ID：{}，过期时间：{}秒", cacheKey, id, expireSeconds);
                                } else {
                                    log.warn("缓存同步 - 未找到ID为{}的数据", id);
                                }
                            } catch (Exception e) {
                                log.error("缓存同步 - 查询数据异常：{}", e.getMessage(), e);
                            }
                        }
                    }
                } else {
                    // 直接使用消息中的值更新缓存（这种情况下可能缺少merchantName和categoryName）
                    log.warn("缓存同步 - 收到不包含requireQuery的消息，可能导致数据不完整");
                    Object value = messageMap.get("value");
                    if (value != null) {
                        String jsonValue = objectMapper.writeValueAsString(value);
                        redisTemplate.opsForValue().set(cacheKey, jsonValue, expireSeconds, TimeUnit.SECONDS);
                        log.info("缓存同步 - 已更新缓存：{}，过期时间：{}秒", cacheKey, expireSeconds);
                    }
                }
            }
        } catch (JsonProcessingException e) {
            log.error("缓存同步 - 消息解析失败：{}", e.getMessage(), e);
        } catch (Exception e) {
            log.error("缓存同步 - 处理消息异常：{}", e.getMessage(), e);
        }
    }
} 